/* crypto/ec/ec.h */
/*
 * Originally written by Bodo Moeller for the OpenSSL project.
 */
/**
 * \file crypto/ec/ec.h Include file for the OpenSSL EC functions
 * \author Originally written by Bodo Moeller for the OpenSSL project
 */
/* ====================================================================
 * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *   software must display the following acknowledgment:
 *   "This product includes software developed by the OpenSSL Project
 *   for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *   endorse or promote products derived from this software without
 *   prior written permission. For written permission, please contact
 *   openssl-core@openssl.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *   nor may "OpenSSL" appear in their names without prior written
 *   permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *   acknowledgment:
 *   "This product includes software developed by the OpenSSL Project
 *   for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */
/* ====================================================================
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 *
 * Portions of the attached software ("Contribution") are developed by
 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
 *
 * The Contribution is licensed pursuant to the OpenSSL open source
 * license provided above.
 *
 * The elliptic curve binary polynomial software is originally written by
 * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
 *
 */

module deimos.openssl.ec;

import deimos.openssl._d_util;

public import deimos.openssl.opensslconf;
import deimos.openssl.evp; // Needed for EVP_PKEY_ALG_CTRL and ec_key_st.

version (OPENSSL_NO_EC) {
  static assert(false, "EC is disabled.");
}

public import deimos.openssl.asn1;
public import deimos.openssl.symhacks;
version(OPENSSL_NO_DEPRECATED) {} else {
public import deimos.openssl.bn;
}

extern (C):
nothrow:

static if (!is(typeof(OPENSSL_ECC_MAX_FIELD_BITS))) {
	enum OPENSSL_ECC_MAX_FIELD_BITS = 661;
}

/** Enum for the point conversion form as defined in X9.62 (ECDSA)
 * for the encoding of a elliptic curve point (x,y) */
enum point_conversion_form_t {
	init = 0, // Ensure initial values in D is zero
	/** the point is encoded as z||x, where the octet z specifies
	 * which solution of the quadratic equation y is  */
	POINT_CONVERSION_COMPRESSED = 2,
	/** the point is encoded as z||x||y, where z is the octet 0x02  */
	POINT_CONVERSION_UNCOMPRESSED = 4,
	/** the point is encoded as z||x||y, where the octet z specifies
         * which solution of the quadratic equation y is  */
	POINT_CONVERSION_HYBRID = 6
}


struct ec_method_st;
alias ec_method_st EC_METHOD;

struct ec_group_st;
	/*
	 EC_METHOD* meth;
	 -- field definition
	 -- curve coefficients
	 -- optional generator with associated information (order, cofactor)
	 -- optional extra data (precomputed table for fast computation of multiples of generator)
	 -- ASN1 stuff
	*/
alias ec_group_st EC_GROUP;

struct ec_point_st;
alias ec_point_st EC_POINT;


/********************************************************************/
/*              EC_METHODs for curves over GF(p)                   */
/********************************************************************/

/** Returns the basic GFp ec methods which provides the basis for the
 * optimized methods.
 * \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GFp_simple_method();

/** Returns GFp methods using montgomery multiplication.
 * \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GFp_mont_method();

/** Returns GFp methods using optimized methods for NIST recommended curves
 * \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GFp_nist_method();

version(OPENSSL_NO_EC_NISTP_64_GCC_128) {} else {
/** Returns 64-bit optimized methods for nistp224
 *  \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GFp_nistp224_method();

/** Returns 64-bit optimized methods for nistp256
 *  \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GFp_nistp256_method();

/** Returns 64-bit optimized methods for nistp521
 *  \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GFp_nistp521_method();
}

version(OPENSSL_NO_EC2M) {} else {
/********************************************************************/
/*          EC_METHOD for curves over GF(2^m)                      */
/********************************************************************/

/** Returns the basic GF2m ec method
 * \return  EC_METHOD object
 */
const(EC_METHOD)* EC_GF2m_simple_method();

}


/********************************************************************/
/*                  EC_GROUP functions                             */
/********************************************************************/

/** Creates a new EC_GROUP object
 * \param   meth  EC_METHOD to use
 * \return  newly created EC_GROUP object or NULL in case of an error.
 */
EC_GROUP* EC_GROUP_new(const(EC_METHOD)* meth);

/** Frees a EC_GROUP object
 * \param  group  EC_GROUP object to be freed.
 */
void EC_GROUP_free(EC_GROUP* group);

/** Clears and frees a EC_GROUP object
 * \param  group  EC_GROUP object to be cleared and freed.
 */
void EC_GROUP_clear_free(EC_GROUP* group);

/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD.
 * \param  dst  destination EC_GROUP object
 * \param  src  source EC_GROUP object
 * \return 1 on success and 0 if an error occurred.
 */
int EC_GROUP_copy(EC_GROUP* dst, const(EC_GROUP)* src);

/** Creates a new EC_GROUP object and copies the copies the content
 * form src to the newly created EC_KEY object
 * \param  src  source EC_GROUP object
 * \return newly created EC_GROUP object or NULL in case of an error.
 */
EC_GROUP* EC_GROUP_dup(const(EC_GROUP)* src);

/** Returns the EC_METHOD of the EC_GROUP object.
 * \param  group  EC_GROUP object
 * \return EC_METHOD used in this EC_GROUP object.
 */
const(EC_METHOD)* EC_GROUP_method_of(const(EC_GROUP)* group);

/** Returns the field type of the EC_METHOD.
 * \param  meth  EC_METHOD object
 * \return NID of the underlying field type OID.
 */
int EC_METHOD_get_field_type(const(EC_METHOD)* meth);

/** Sets the generator and it's order/cofactor of a EC_GROUP object.
 * \param  group      EC_GROUP object
 * \param  generator  EC_POINT object with the generator.
 * \param  order      the order of the group generated by the generator.
 * \param  cofactor   the index of the sub-group generated by the generator
 *                    in the group of all points on the elliptic curve.
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_set_generator(EC_GROUP* group, const(EC_POINT)* generator, const(BIGNUM)* order, const(BIGNUM)* cofactor);

/** Returns the generator of a EC_GROUP object.
 * \param  group  EC_GROUP object
 * \return the currently used generator (possibly NULL).
 */
const(EC_POINT)* EC_GROUP_get0_generator(const(EC_GROUP)* group);

/** Gets the order of a EC_GROUP
 * \param  group  EC_GROUP object
 * \param  order  BIGNUM to which the order is copied
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_get_order(const(EC_GROUP)* group, BIGNUM* order, BN_CTX* ctx);

/** Gets the cofactor of a EC_GROUP
 * \param  group     EC_GROUP object
 * \param  cofactor  BIGNUM to which the cofactor is copied
 * \param  ctx       BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_get_cofactor(const(EC_GROUP)* group, BIGNUM* cofactor, BN_CTX* ctx);

/** Sets the name of a EC_GROUP object
 * \param  group  EC_GROUP object
 * \param  nid    NID of the curve name OID
 */
void EC_GROUP_set_curve_name(EC_GROUP* group, int nid);

/** Returns the curve name of a EC_GROUP object
 * \param  group  EC_GROUP object
 * \return NID of the curve name OID or 0 if not set.
 */
int EC_GROUP_get_curve_name(const(EC_GROUP)* group);

void EC_GROUP_set_asn1_flag(EC_GROUP* group, int flag);
int EC_GROUP_get_asn1_flag(const(EC_GROUP)* group);

void EC_GROUP_set_point_conversion_form(EC_GROUP* group, point_conversion_form_t);
point_conversion_form_t EC_GROUP_get_point_conversion_form(const(EC_GROUP)*);

ubyte* EC_GROUP_get0_seed(const(EC_GROUP)* x);
size_t EC_GROUP_get_seed_len(const(EC_GROUP)*);
size_t EC_GROUP_set_seed(EC_GROUP*, const(ubyte)*, size_t len);

/** Sets the parameter of a ec over GFp defined by y^2 = x^3 + a*x + b
 * \param  group  EC_GROUP object
 * \param  p      BIGNUM with the prime number
 * \param  a      BIGNUM with parameter a of the equation
 * \param  b      BIGNUM with parameter b of the equation
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_set_curve_GFp(EC_GROUP* group, const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);

/** Gets the parameter of the ec over GFp defined by y^2 = x^3 + a*x + b
 * \param  group  EC_GROUP object
 * \param  p      BIGNUM for the prime number
 * \param  a      BIGNUM for parameter a of the equation
 * \param  b      BIGNUM for parameter b of the equation
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_get_curve_GFp(const(EC_GROUP)* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);

version(OPENSSL_NO_EC2M) {} else {
/** Sets the parameter of a ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b
 * \param  group  EC_GROUP object
 * \param  p      BIGNUM with the polynomial defining the underlying field
 * \param  a      BIGNUM with parameter a of the equation
 * \param  b      BIGNUM with parameter b of the equation
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_set_curve_GF2m(EC_GROUP* group, const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);

/** Gets the parameter of the ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b
 * \param  group  EC_GROUP object
 * \param  p      BIGNUM for the polynomial defining the underlying field
 * \param  a      BIGNUM for parameter a of the equation
 * \param  b      BIGNUM for parameter b of the equation
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_get_curve_GF2m(const(EC_GROUP)* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);
}
/** Returns the number of bits needed to represent a field element
 * \param  group  EC_GROUP object
 * \return number of bits needed to represent a field element
 */
int EC_GROUP_get_degree(const(EC_GROUP)* group);

/** Checks whether the parameter in the EC_GROUP define a valid ec group
 * \param  group  EC_GROUP object
 * \param  ctx    BN_CTX object (optional)
 * \return 1 if group is a valid ec group and 0 otherwise
 */
int EC_GROUP_check(const(EC_GROUP)* group, BN_CTX* ctx);

/** Checks whether the discriminant of the elliptic curve is zero or not
 * \param  group  EC_GROUP object
 * \param  ctx    BN_CTX object (optional)
 * \return 1 if the discriminant is not zero and 0 otherwise
 */
int EC_GROUP_check_discriminant(const(EC_GROUP)* group, BN_CTX* ctx);

/** Compares two EC_GROUP objects
 * \param  a    first EC_GROUP object
 * \param  b    second EC_GROUP object
 * \param  ctx  BN_CTX object (optional)
 * \return 0 if both groups are equal and 1 otherwise
 */
int EC_GROUP_cmp(const(EC_GROUP)* a, const(EC_GROUP)* b, BN_CTX* ctx);

/* EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*()
 * after choosing an appropriate EC_METHOD */

/** Creates a new EC_GROUP object with the specified parameters defined
 * over GFp (defined by the equation y^2 = x^3 + a*x + b)
 * \param  p    BIGNUM with the prime number
 * \param  a    BIGNUM with the parameter a of the equation
 * \param  b    BIGNUM with the parameter b of the equation
 * \param  ctx  BN_CTX object (optional)
 * \return newly created EC_GROUP object with the specified parameters
 */
EC_GROUP* EC_GROUP_new_curve_GFp(const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);
version(OPENSSL_NO_EC2M) {} else {
/** Creates a new EC_GROUP object with the specified parameters defined
 * over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b)
 * \param  p    BIGNUM with the polynomial defining the underlying field
 * \param  a    BIGNUM with the parameter a of the equation
 * \param  b    BIGNUM with the parameter b of the equation
 * \param  ctx  BN_CTX object (optional)
 * \return newly created EC_GROUP object with the specified parameters
 */
EC_GROUP* EC_GROUP_new_curve_GF2m(const(BIGNUM)* p, const(BIGNUM)* a, const(BIGNUM)* b, BN_CTX* ctx);
}
/** Creates a EC_GROUP object with a curve specified by a NID
 * \param  nid  NID of the OID of the curve name
 * \return newly created EC_GROUP object with specified curve or NULL
 *         if an error occurred
 */
EC_GROUP* EC_GROUP_new_by_curve_name(int nid);


/********************************************************************/
/*              handling of internal curves                        */
/********************************************************************/

struct EC_builtin_curve {
	int nid;
	const(char)* comment;
	}

/* EC_builtin_curves(EC_builtin_curve* r, size_t size) returns number
 * of all available curves or zero if a error occurred.
 * In case r ist not zero nitems EC_builtin_curve structures
 * are filled with the data of the first nitems internal groups */
size_t EC_get_builtin_curves(EC_builtin_curve* r, size_t nitems);


/********************************************************************/
/*                   EC_POINT functions                            */
/********************************************************************/

/** Creates a new EC_POINT object for the specified EC_GROUP
 * \param  group  EC_GROUP the underlying EC_GROUP object
 * \return newly created EC_POINT object or NULL if an error occurred
 */
EC_POINT* EC_POINT_new(const(EC_GROUP)* group);

/** Frees a EC_POINT object
 * \param  point  EC_POINT object to be freed
 */
void EC_POINT_free(EC_POINT* point);

/** Clears and frees a EC_POINT object
 * \param  point  EC_POINT object to be cleared and freed
 */
void EC_POINT_clear_free(EC_POINT* point);

/** Copies EC_POINT object
 * \param  dst  destination EC_POINT object
 * \param  src  source EC_POINT object
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_copy(EC_POINT* dst, const(EC_POINT)* src);

/** Creates a new EC_POINT object and copies the content of the supplied
 * EC_POINT
 * \param  src    source EC_POINT object
 * \param  group  underlying the EC_GROUP object
 * \return newly created EC_POINT object or NULL if an error occurred
 */
EC_POINT* EC_POINT_dup(const(EC_POINT)* src, const(EC_GROUP)* group);

/** Returns the EC_METHOD used in EC_POINT object
 * \param  point  EC_POINT object
 * \return the EC_METHOD used
 */
const(EC_METHOD)* EC_POINT_method_of(const(EC_POINT)* point);

/** Sets a point to infinity (neutral element)
 * \param  group  underlying EC_GROUP object
 * \param  point  EC_POINT to set to infinity
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_set_to_infinity(const(EC_GROUP)* group, EC_POINT* point);

/** Sets the jacobian projective coordinates of a EC_POINT over GFp
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM with the x-coordinate
 * \param  y      BIGNUM with the y-coordinate
 * \param  z      BIGNUM with the z-coordinate
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_set_Jprojective_coordinates_GFp(const(EC_GROUP)* group, EC_POINT* p,
	const(BIGNUM)* x, const(BIGNUM)* y, const(BIGNUM)* z, BN_CTX* ctx);

/** Gets the jacobian projective coordinates of a EC_POINT over GFp
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM for the x-coordinate
 * \param  y      BIGNUM for the y-coordinate
 * \param  z      BIGNUM for the z-coordinate
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_get_Jprojective_coordinates_GFp(const(EC_GROUP)* group,
	const(EC_POINT)* p, BIGNUM* x, BIGNUM* y, BIGNUM* z, BN_CTX* ctx);

/** Sets the affine coordinates of a EC_POINT over GFp
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM with the x-coordinate
 * \param  y      BIGNUM with the y-coordinate
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_set_affine_coordinates_GFp(const(EC_GROUP)* group, EC_POINT* p,
	const(BIGNUM)* x, const(BIGNUM)* y, BN_CTX* ctx);

/** Gets the affine coordinates of a EC_POINT over GFp
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM for the x-coordinate
 * \param  y      BIGNUM for the y-coordinate
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_get_affine_coordinates_GFp(const(EC_GROUP)* group,
	const(EC_POINT)* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);

/** Sets the x9.62 compressed coordinates of a EC_POINT over GFp
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM with x-coordinate
 * \param  y_bit  integer with the y-Bit (either 0 or 1)
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_set_compressed_coordinates_GFp(const(EC_GROUP)* group, EC_POINT* p,
	const(BIGNUM)* x, int y_bit, BN_CTX* ctx);
version(OPENSSL_NO_EC2M) {} else {
/** Sets the affine coordinates of a EC_POINT over GF2m
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM with the x-coordinate
 * \param  y      BIGNUM with the y-coordinate
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_set_affine_coordinates_GF2m(const(EC_GROUP)* group, EC_POINT* p,
	const(BIGNUM)* x, const(BIGNUM)* y, BN_CTX* ctx);

/** Gets the affine coordinates of a EC_POINT over GF2m
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM for the x-coordinate
 * \param  y      BIGNUM for the y-coordinate
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_get_affine_coordinates_GF2m(const(EC_GROUP)* group,
	const(EC_POINT)* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);

/** Sets the x9.62 compressed coordinates of a EC_POINT over GF2m
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  x      BIGNUM with x-coordinate
 * \param  y_bit  integer with the y-Bit (either 0 or 1)
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_set_compressed_coordinates_GF2m(const(EC_GROUP)* group, EC_POINT* p,
	const(BIGNUM)* x, int y_bit, BN_CTX* ctx);
}
/** Encodes a EC_POINT object to a octet string
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  form   point conversion form
 * \param  buf    memory buffer for the result. If NULL the function returns
 *                required buffer size.
 * \param  len    length of the memory buffer
 * \param  ctx    BN_CTX object (optional)
 * \return the length of the encoded octet string or 0 if an error occurred
 */
size_t EC_POINT_point2oct(const(EC_GROUP)* group, const(EC_POINT)* p,
	point_conversion_form_t form,
        ubyte* buf, size_t len, BN_CTX* ctx);

/** Decodes a EC_POINT from a octet string
 * \param  group  underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \param  buf    memory buffer with the encoded ec point
 * \param  len    length of the encoded ec point
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_oct2point(const(EC_GROUP)* group, EC_POINT* p,
        const(ubyte)* buf, size_t len, BN_CTX* ctx);

/* other interfaces to point2oct/oct2point: */
BIGNUM* EC_POINT_point2bn(const(EC_GROUP)*, const(EC_POINT)*,
	point_conversion_form_t form, BIGNUM*, BN_CTX*);
EC_POINT* EC_POINT_bn2point(const(EC_GROUP)*, const(BIGNUM)*,
	EC_POINT*, BN_CTX*);
char* EC_POINT_point2hex(const(EC_GROUP)*, const(EC_POINT)*,
	point_conversion_form_t form, BN_CTX*);
EC_POINT* EC_POINT_hex2point(const(EC_GROUP)*, const(char)*,
	EC_POINT*, BN_CTX*);


/********************************************************************/
/*        functions for doing EC_POINT arithmetic                  */
/********************************************************************/

/** Computes the sum of two EC_POINT
 * \param  group  underlying EC_GROUP object
 * \param  r      EC_POINT object for the result (r = a + b)
 * \param  a      EC_POINT object with the first summand
 * \param  b      EC_POINT object with the second summand
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_add(const(EC_GROUP)* group, EC_POINT* r, const(EC_POINT)* a, const(EC_POINT)* b, BN_CTX* ctx);

/** Computes the double of a EC_POINT
 * \param  group  underlying EC_GROUP object
 * \param  r      EC_POINT object for the result (r = 2* a)
 * \param  a      EC_POINT object
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_dbl(const(EC_GROUP)* group, EC_POINT* r, const(EC_POINT)* a, BN_CTX* ctx);

/** Computes the inverse of a EC_POINT
 * \param  group  underlying EC_GROUP object
 * \param  a      EC_POINT object to be inverted (it's used for the result as well)
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_invert(const(EC_GROUP)* group, EC_POINT* a, BN_CTX* ctx);

/** Checks whether the point is the neutral element of the group
 * \param  group  the underlying EC_GROUP object
 * \param  p      EC_POINT object
 * \return 1 if the point is the neutral element and 0 otherwise
 */
int EC_POINT_is_at_infinity(const(EC_GROUP)* group, const(EC_POINT)* p);

/** Checks whether the point is on the curve
 * \param  group  underlying EC_GROUP object
 * \param  point  EC_POINT object to check
 * \param  ctx    BN_CTX object (optional)
 * \return 1 if point if on the curve and 0 otherwise
 */
int EC_POINT_is_on_curve(const(EC_GROUP)* group, const(EC_POINT)* point, BN_CTX* ctx);

/** Compares two EC_POINTs
 * \param  group  underlying EC_GROUP object
 * \param  a      first EC_POINT object
 * \param  b      second EC_POINT object
 * \param  ctx    BN_CTX object (optional)
 * \return 0 if both points are equal and a value != 0 otherwise
 */
int EC_POINT_cmp(const(EC_GROUP)* group, const(EC_POINT)* a, const(EC_POINT)* b, BN_CTX* ctx);

int EC_POINT_make_affine(const(EC_GROUP)* group, EC_POINT* point, BN_CTX* ctx);
int EC_POINTs_make_affine(const(EC_GROUP)* group, size_t num, EC_POINT*[] points, BN_CTX* ctx);

/** Computes r = generator* n sum_{i=0}^num p[i] * m[i]
 * \param  group  underlying EC_GROUP object
 * \param  r      EC_POINT object for the result
 * \param  n      BIGNUM with the multiplier for the group generator (optional)
 * \param  num    number futher summands
 * \param  p      array of size num of EC_POINT objects
 * \param  m      array of size num of BIGNUM objects
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINTs_mul(const(EC_GROUP)* group, EC_POINT* r, const(BIGNUM)* n, size_t num, const(EC_POINT)*[] p, const(BIGNUM)*[] m, BN_CTX* ctx);

/** Computes r = generator* n + q* m
 * \param  group  underlying EC_GROUP object
 * \param  r      EC_POINT object for the result
 * \param  n      BIGNUM with the multiplier for the group generator (optional)
 * \param  q      EC_POINT object with the first factor of the second summand
 * \param  m      BIGNUM with the second factor of the second summand
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_POINT_mul(const(EC_GROUP)* group, EC_POINT* r, const(BIGNUM)* n, const(EC_POINT)* q, const(BIGNUM)* m, BN_CTX* ctx);

/** Stores multiples of generator for faster point multiplication
 * \param  group  EC_GROUP object
 * \param  ctx    BN_CTX object (optional)
 * \return 1 on success and 0 if an error occured
 */
int EC_GROUP_precompute_mult(EC_GROUP* group, BN_CTX* ctx);

/** Reports whether a precomputation has been done
 * \param  group  EC_GROUP object
 * \return 1 if a pre-computation has been done and 0 otherwise
 */
int EC_GROUP_have_precompute_mult(const(EC_GROUP)* group);


/********************************************************************/
/*                      ASN1 stuff                                 */
/********************************************************************/

/* EC_GROUP_get_basis_type() returns the NID of the basis type
 * used to represent the field elements */
int EC_GROUP_get_basis_type(const(EC_GROUP)*);
version(OPENSSL_NO_EC2M) {} else {
int EC_GROUP_get_trinomial_basis(const(EC_GROUP)*, uint* k);
int EC_GROUP_get_pentanomial_basis(const(EC_GROUP)*, uint* k1,
	uint* k2, uint* k3);
}

enum OPENSSL_EC_NAMED_CURVE = 0x001;

struct ecpk_parameters_st;
alias ecpk_parameters_st ECPKPARAMETERS;

EC_GROUP* d2i_ECPKParameters(EC_GROUP**, const(ubyte)** in_, c_long len);
int i2d_ECPKParameters(const(EC_GROUP)*, ubyte** out_);

/+XXX
#define d2i_ECPKParameters_bio(bp,x) ASN1_d2i_bio_of(EC_GROUP,NULL,d2i_ECPKParameters,bp,x)
#define i2d_ECPKParameters_bio(bp,x) ASN1_i2d_bio_of_const(EC_GROUP,i2d_ECPKParameters,bp,x)
#define d2i_ECPKParameters_fp(fp,x) (EC_GROUP*)ASN1_d2i_fp(NULL, \
                (ExternC!(char* function()) )d2i_ECPKParameters,(fp),(ubyte**)(x))
#define i2d_ECPKParameters_fp(fp,x) ASN1_i2d_fp(i2d_ECPKParameters,(fp), \
		(ubyte*)(x))
+/

version(OPENSSL_NO_BIO) {} else {
int     ECPKParameters_print(BIO* bp, const(EC_GROUP)* x, int off);
}
version(OPENSSL_NO_FP_API) {} else {
int     ECPKParameters_print_fp(FILE* fp, const(EC_GROUP)* x, int off);
}


/********************************************************************/
/*                     EC_KEY functions                            */
/********************************************************************/

/*struct ec_key_st;*/
alias ec_key_st EC_KEY;

/* some values for the encoding_flag */
enum EC_PKEY_NO_PARAMETERS = 0x001;
enum EC_PKEY_NO_PUBKEY = 0x002;

/* some values for the flags field */
enum EC_FLAG_NON_FIPS_ALLOW = 0x1;
enum EC_FLAG_FIPS_CHECKED = 0x2;

/** Creates a new EC_KEY object.
 * \return EC_KEY object or NULL if an error occurred.
 */
EC_KEY* EC_KEY_new();

int EC_KEY_get_flags(const(EC_KEY)* key);

void EC_KEY_set_flags(EC_KEY* key, int flags);

void EC_KEY_clear_flags(EC_KEY* key, int flags);

/** Creates a new EC_KEY object using a named curve as underlying
 * EC_GROUP object.
 * \param  nid  NID of the named curve.
 * \return EC_KEY object or NULL if an error occurred.
 */
EC_KEY* EC_KEY_new_by_curve_name(int nid);

/** Frees a EC_KEY object.
 * \param  key  EC_KEY object to be freed.
 */
void EC_KEY_free(EC_KEY* key);

/** Copies a EC_KEY object.
 * \param  dst  destination EC_KEY object
 * \param  src  src EC_KEY object
 * \return dst or NULL if an error occurred.
 */
EC_KEY* EC_KEY_copy(EC_KEY* dst, const(EC_KEY)* src);

/** Creates a new EC_KEY object and copies the content from src to it.
 * \param  src  the source EC_KEY object
 * \return newly created EC_KEY object or NULL if an error occurred.
 */
EC_KEY* EC_KEY_dup(const(EC_KEY)* src);

/** Increases the internal reference count of a EC_KEY object.
 * \param  key  EC_KEY object
 * \return 1 on success and 0 if an error occurred.
 */
int EC_KEY_up_ref(EC_KEY* key);

/** Returns the EC_GROUP object of a EC_KEY object
 * \param  key  EC_KEY object
 * \return the EC_GROUP object (possibly NULL).
 */
const(EC_GROUP)* EC_KEY_get0_group(const(EC_KEY)* key);

/** Sets the EC_GROUP of a EC_KEY object.
 * \param  key    EC_KEY object
 * \param  group  EC_GROUP to use in the EC_KEY object (note: the EC_KEY
 *                object will use an own copy of the EC_GROUP).
 * \return 1 on success and 0 if an error occurred.
 */
int EC_KEY_set_group(EC_KEY* key, const(EC_GROUP)* group);

/** Returns the private key of a EC_KEY object.
 * \param  key  EC_KEY object
 * \return a BIGNUM with the private key (possibly NULL).
 */
const(BIGNUM)* EC_KEY_get0_private_key(const(EC_KEY)* key);

/** Sets the private key of a EC_KEY object.
 * \param  key  EC_KEY object
 * \param  prv  BIGNUM with the private key (note: the EC_KEY object
 *              will use an own copy of the BIGNUM).
 * \return 1 on success and 0 if an error occurred.
 */
int EC_KEY_set_private_key(EC_KEY* key, const(BIGNUM)* prv);

/** Returns the public key of a EC_KEY object.
 * \param  key  the EC_KEY object
 * \return a EC_POINT object with the public key (possibly NULL)
 */
const(EC_POINT)* EC_KEY_get0_public_key(const(EC_KEY)* key);

/** Sets the public key of a EC_KEY object.
 * \param  key  EC_KEY object
 * \param  pub  EC_POINT object with the public key (note: the EC_KEY object
 *              will use an own copy of the EC_POINT object).
 * \return 1 on success and 0 if an error occurred.
 */
int EC_KEY_set_public_key(EC_KEY* key, const(EC_POINT)* pub);

uint EC_KEY_get_enc_flags(const(EC_KEY)* key);
void EC_KEY_set_enc_flags(EC_KEY* eckey, uint);
point_conversion_form_t EC_KEY_get_conv_form(const(EC_KEY)* key);
void EC_KEY_set_conv_form(EC_KEY* eckey, point_conversion_form_t);
/* functions to set/get method specific data  */
void* EC_KEY_get_key_method_data(EC_KEY* eckey,
	ExternC!(void* function(void*)) dup_func, ExternC!(void function(void*)) free_func, ExternC!(void function(void*)) clear_free_func);
/** Sets the key method data of an EC_KEY object, if none has yet been set.
 *  \param  key              EC_KEY object
 *  \param  data             opaque data to install.
 *  \param  dup_func         a function that duplicates |data|.
 *  \param  free_func        a function that frees |data|.
 *  \param  clear_free_func  a function that wipes and frees |data|.
 *  \return the previously set data pointer, or NULL if |data| was inserted.
 */
void *EC_KEY_insert_key_method_data(EC_KEY* key, void* data,
	ExternC!(void* function(void*)) dup_func, ExternC!(void function(void*)) free_func, ExternC!(void function(void*)) clear_free_func);
/* wrapper functions for the underlying EC_GROUP object */
void EC_KEY_set_asn1_flag(EC_KEY* eckey, int);

/** Creates a table of pre-computed multiples of the generator to
 * accelerate further EC_KEY operations.
 * \param  key  EC_KEY object
 * \param  ctx  BN_CTX object (optional)
 * \return 1 on success and 0 if an error occurred.
 */
int EC_KEY_precompute_mult(EC_KEY* key, BN_CTX* ctx);

/** Creates a new ec private (and optional a new public) key.
 * \param  key  EC_KEY object
 * \return 1 on success and 0 if an error occurred.
 */
int EC_KEY_generate_key(EC_KEY* key);

/** Verifies that a private and/or public key is valid.
 * \param  key  the EC_KEY object
 * \return 1 on success and 0 otherwise.
 */
int EC_KEY_check_key(const(EC_KEY)* key);


/********************************************************************/
/*       de- and encoding functions for SEC1 ECPrivateKey          */
/********************************************************************/

/** Decodes a private key from a memory buffer.
 * \param  key  a pointer to a EC_KEY object which should be used (or NULL)
 * \param  in   pointer to memory with the DER encoded private key
 * \param  len  length of the DER encoded private key
 * \return the decoded private key or NULL if an error occurred.
 */
EC_KEY* d2i_ECPrivateKey(EC_KEY** key, const(ubyte)** in_, c_long len);

/** Encodes a private key object and stores the result in a buffer.
 * \param  key  the EC_KEY object to encode
 * \param  out  the buffer for the result (if NULL the function returns number
 *              of bytes needed).
 * \return 1 on success and 0 if an error occurred.
 */
int i2d_ECPrivateKey(EC_KEY* key, ubyte** out_);


/********************************************************************/
/*       de- and encoding functions for EC parameters              */
/********************************************************************/

/** Decodes ec parameter from a memory buffer.
 * \param  key  a pointer to a EC_KEY object which should be used (or NULL)
 * \param  in   pointer to memory with the DER encoded ec parameters
 * \param  len  length of the DER encoded ec parameters
 * \return a EC_KEY object with the decoded parameters or NULL if an error
 *         occurred.
 */
EC_KEY* d2i_ECParameters(EC_KEY** key, const(ubyte)** in_, c_long len);

/** Encodes ec parameter and stores the result in a buffer.
 * \param  key  the EC_KEY object with ec paramters to encode
 * \param  out  the buffer for the result (if NULL the function returns number
 *              of bytes needed).
 * \return 1 on success and 0 if an error occurred.
 */
int i2d_ECParameters(EC_KEY* key, ubyte** out_);


/********************************************************************/
/*        de- and encoding functions for EC public key             */
/*        (octet string, not DER -- hence 'o2i' and 'i2o')         */
/********************************************************************/

/** Decodes a ec public key from a octet string.
 * \param  key  a pointer to a EC_KEY object which should be used
 * \param  in   memory buffer with the encoded public key
 * \param  len  length of the encoded public key
 * \return EC_KEY object with decoded public key or NULL if an error
 *         occurred.
 */
EC_KEY* o2i_ECPublicKey(EC_KEY** key, const(ubyte)** in_, c_long len);

/** Encodes a ec public key in an octet string.
 * \param  key  the EC_KEY object with the public key
 * \param  out  the buffer for the result (if NULL the function returns number
 *              of bytes needed).
 * \return 1 on success and 0 if an error occurred
 */
int i2o_ECPublicKey(EC_KEY* key, ubyte** out_);

version(OPENSSL_NO_BIO) {} else {
/** Prints out the ec parameters on human readable form.
 * \param  bp   BIO object to which the information is printed
 * \param  key  EC_KEY object
 * \return 1 on success and 0 if an error occurred
 */
int	ECParameters_print(BIO* bp, const(EC_KEY)* key);

/** Prints out the contents of a EC_KEY object
 * \param  bp   BIO object to which the information is printed
 * \param  key  EC_KEY object
 * \param  off  line offset
 * \return 1 on success and 0 if an error occurred
 */
int	EC_KEY_print(BIO* bp, const(EC_KEY)* key, int off);

}
version(OPENSSL_NO_FP_API) {} else {
/** Prints out the ec parameters on human readable form.
 * \param  fp   file descriptor to which the information is printed
 * \param  key  EC_KEY object
 * \return 1 on success and 0 if an error occurred
 */
int	ECParameters_print_fp(FILE* fp, const(EC_KEY)* key);

/** Prints out the contents of a EC_KEY object
 * \param  fp   file descriptor to which the information is printed
 * \param  key  EC_KEY object
 * \param  off  line offset
 * \return 1 on success and 0 if an error occurred
 */
int	EC_KEY_print_fp(FILE* fp, const(EC_KEY)* key, int off);

}

auto ECParameters_dup()(EC_KEY* x) {return ASN1_dup_of!EC_KEY(&i2d_ECParameters,&d2i_ECParameters,x); }

//#ifndef __cplusplus
//#if defined(__SUNPRO_C)
//#  if __SUNPRO_C >= 0x520
//# pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE)
//#  endif
//# endif
//#endif

auto EVP_PKEY_CTX_set_ec_paramgen_curve_nid()(EVP_PKEY_CTX* ctx, int nid) {
	return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, EVP_PKEY_OP_PARAMGEN,
				EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, nid, null);
}

enum EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID = (EVP_PKEY_ALG_CTRL + 1);

/* BEGIN ERROR CODES */
/* The following lines are auto generated by the script mkerr.pl. Any changes
 * made after this point may be overwritten when the script is next run.
 */
void ERR_load_EC_strings();

/* Error codes for the EC functions. */

/* Function codes. */
enum EC_F_BN_TO_FELEM = 224;
enum EC_F_COMPUTE_WNAF = 143;
enum EC_F_D2I_ECPARAMETERS = 144;
enum EC_F_D2I_ECPKPARAMETERS = 145;
enum EC_F_D2I_ECPRIVATEKEY = 146;
enum EC_F_DO_EC_KEY_PRINT = 221;
enum EC_F_ECKEY_PARAM2TYPE = 223;
enum EC_F_ECKEY_PARAM_DECODE = 212;
enum EC_F_ECKEY_PRIV_DECODE = 213;
enum EC_F_ECKEY_PRIV_ENCODE = 214;
enum EC_F_ECKEY_PUB_DECODE = 215;
enum EC_F_ECKEY_PUB_ENCODE = 216;
enum EC_F_ECKEY_TYPE2PARAM = 220;
enum EC_F_ECPARAMETERS_PRINT = 147;
enum EC_F_ECPARAMETERS_PRINT_FP = 148;
enum EC_F_ECPKPARAMETERS_PRINT = 149;
enum EC_F_ECPKPARAMETERS_PRINT_FP = 150;
enum EC_F_ECP_NIST_MOD_192 = 203;
enum EC_F_ECP_NIST_MOD_224 = 204;
enum EC_F_ECP_NIST_MOD_256 = 205;
enum EC_F_ECP_NIST_MOD_521 = 206;
enum EC_F_EC_ASN1_GROUP2CURVE = 153;
enum EC_F_EC_ASN1_GROUP2FIELDID = 154;
enum EC_F_EC_ASN1_GROUP2PARAMETERS = 155;
enum EC_F_EC_ASN1_GROUP2PKPARAMETERS = 156;
enum EC_F_EC_ASN1_PARAMETERS2GROUP = 157;
enum EC_F_EC_ASN1_PKPARAMETERS2GROUP = 158;
enum EC_F_EC_EX_DATA_SET_DATA = 211;
enum EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY = 208;
enum EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT = 159;
enum EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE = 195;
enum EC_F_EC_GF2M_SIMPLE_OCT2POINT = 160;
enum EC_F_EC_GF2M_SIMPLE_POINT2OCT = 161;
enum EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES = 162;
enum EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES = 163;
enum EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES = 164;
enum EC_F_EC_GFP_MONT_FIELD_DECODE = 133;
enum EC_F_EC_GFP_MONT_FIELD_ENCODE = 134;
enum EC_F_EC_GFP_MONT_FIELD_MUL = 131;
enum EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE = 209;
enum EC_F_EC_GFP_MONT_FIELD_SQR = 132;
enum EC_F_EC_GFP_MONT_GROUP_SET_CURVE = 189;
enum EC_F_EC_GFP_MONT_GROUP_SET_CURVE_GFP = 135;
enum EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE = 225;
enum EC_F_EC_GFP_NISTP224_POINTS_MUL = 228;
enum EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES = 226;
enum EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE = 230;
enum EC_F_EC_GFP_NISTP256_POINTS_MUL = 231;
enum EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES = 232;
enum EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE = 233;
enum EC_F_EC_GFP_NISTP521_POINTS_MUL = 234;
enum EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES = 235;
enum EC_F_EC_GFP_NIST_FIELD_MUL = 200;
enum EC_F_EC_GFP_NIST_FIELD_SQR = 201;
enum EC_F_EC_GFP_NIST_GROUP_SET_CURVE = 202;
enum EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT = 165;
enum EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE = 166;
enum EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE_GFP = 100;
enum EC_F_EC_GFP_SIMPLE_GROUP_SET_GENERATOR = 101;
enum EC_F_EC_GFP_SIMPLE_MAKE_AFFINE = 102;
enum EC_F_EC_GFP_SIMPLE_OCT2POINT = 103;
enum EC_F_EC_GFP_SIMPLE_POINT2OCT = 104;
enum EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE = 137;
enum EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES = 167;
enum EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES_GFP = 105;
enum EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES = 168;
enum EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES_GFP = 128;
enum EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES = 169;
enum EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES_GFP = 129;
enum EC_F_EC_GROUP_CHECK = 170;
enum EC_F_EC_GROUP_CHECK_DISCRIMINANT = 171;
enum EC_F_EC_GROUP_COPY = 106;
enum EC_F_EC_GROUP_GET0_GENERATOR = 139;
enum EC_F_EC_GROUP_GET_COFACTOR = 140;
enum EC_F_EC_GROUP_GET_CURVE_GF2M = 172;
enum EC_F_EC_GROUP_GET_CURVE_GFP = 130;
enum EC_F_EC_GROUP_GET_DEGREE = 173;
enum EC_F_EC_GROUP_GET_ORDER = 141;
enum EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS = 193;
enum EC_F_EC_GROUP_GET_TRINOMIAL_BASIS = 194;
enum EC_F_EC_GROUP_NEW = 108;
enum EC_F_EC_GROUP_NEW_BY_CURVE_NAME = 174;
enum EC_F_EC_GROUP_NEW_FROM_DATA = 175;
enum EC_F_EC_GROUP_PRECOMPUTE_MULT = 142;
enum EC_F_EC_GROUP_SET_CURVE_GF2M = 176;
enum EC_F_EC_GROUP_SET_CURVE_GFP = 109;
enum EC_F_EC_GROUP_SET_EXTRA_DATA = 110;
enum EC_F_EC_GROUP_SET_GENERATOR = 111;
enum EC_F_EC_KEY_CHECK_KEY = 177;
enum EC_F_EC_KEY_COPY = 178;
enum EC_F_EC_KEY_GENERATE_KEY = 179;
enum EC_F_EC_KEY_NEW = 182;
enum EC_F_EC_KEY_PRINT = 180;
enum EC_F_EC_KEY_PRINT_FP = 181;
enum EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES = 229;
enum EC_F_EC_POINTS_MAKE_AFFINE = 136;
enum EC_F_EC_POINT_ADD = 112;
enum EC_F_EC_POINT_CMP = 113;
enum EC_F_EC_POINT_COPY = 114;
enum EC_F_EC_POINT_DBL = 115;
enum EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M = 183;
enum EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP = 116;
enum EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP = 117;
enum EC_F_EC_POINT_INVERT = 210;
enum EC_F_EC_POINT_IS_AT_INFINITY = 118;
enum EC_F_EC_POINT_IS_ON_CURVE = 119;
enum EC_F_EC_POINT_MAKE_AFFINE = 120;
enum EC_F_EC_POINT_MUL = 184;
enum EC_F_EC_POINT_NEW = 121;
enum EC_F_EC_POINT_OCT2POINT = 122;
enum EC_F_EC_POINT_POINT2OCT = 123;
enum EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M = 185;
enum EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP = 124;
enum EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M = 186;
enum EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP = 125;
enum EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP = 126;
enum EC_F_EC_POINT_SET_TO_INFINITY = 127;
enum EC_F_EC_PRE_COMP_DUP = 207;
enum EC_F_EC_PRE_COMP_NEW = 196;
enum EC_F_EC_WNAF_MUL = 187;
enum EC_F_EC_WNAF_PRECOMPUTE_MULT = 188;
enum EC_F_I2D_ECPARAMETERS = 190;
enum EC_F_I2D_ECPKPARAMETERS = 191;
enum EC_F_I2D_ECPRIVATEKEY = 192;
enum EC_F_I2O_ECPUBLICKEY = 151;
enum EC_F_NISTP224_PRE_COMP_NEW = 227;
enum EC_F_NISTP256_PRE_COMP_NEW = 236;
enum EC_F_NISTP521_PRE_COMP_NEW = 237;
enum EC_F_O2I_ECPUBLICKEY = 152;
enum EC_F_OLD_EC_PRIV_DECODE = 222;
enum EC_F_PKEY_EC_CTRL = 197;
enum EC_F_PKEY_EC_CTRL_STR = 198;
enum EC_F_PKEY_EC_DERIVE = 217;
enum EC_F_PKEY_EC_KEYGEN = 199;
enum EC_F_PKEY_EC_PARAMGEN = 219;
enum EC_F_PKEY_EC_SIGN = 218;

/* Reason codes. */
enum EC_R_ASN1_ERROR = 115;
enum EC_R_ASN1_UNKNOWN_FIELD = 116;
enum EC_R_BIGNUM_OUT_OF_RANGE = 144;
enum EC_R_BUFFER_TOO_SMALL = 100;
enum EC_R_COORDINATES_OUT_OF_RANGE = 146;
enum EC_R_D2I_ECPKPARAMETERS_FAILURE = 117;
enum EC_R_DECODE_ERROR = 142;
enum EC_R_DISCRIMINANT_IS_ZERO = 118;
enum EC_R_EC_GROUP_NEW_BY_NAME_FAILURE = 119;
enum EC_R_FIELD_TOO_LARGE = 143;
enum EC_R_GF2M_NOT_SUPPORTED = 147;
enum EC_R_GROUP2PKPARAMETERS_FAILURE = 120;
enum EC_R_I2D_ECPKPARAMETERS_FAILURE = 121;
enum EC_R_INCOMPATIBLE_OBJECTS = 101;
enum EC_R_INVALID_ARGUMENT = 112;
enum EC_R_INVALID_COMPRESSED_POINT = 110;
enum EC_R_INVALID_COMPRESSION_BIT = 109;
enum EC_R_INVALID_CURVE = 141;
enum EC_R_INVALID_DIGEST_TYPE = 138;
enum EC_R_INVALID_ENCODING = 102;
enum EC_R_INVALID_FIELD = 103;
enum EC_R_INVALID_FORM = 104;
enum EC_R_INVALID_GROUP_ORDER = 122;
enum EC_R_INVALID_PENTANOMIAL_BASIS = 132;
enum EC_R_INVALID_PRIVATE_KEY = 123;
enum EC_R_INVALID_TRINOMIAL_BASIS = 137;
enum EC_R_KEYS_NOT_SET = 140;
enum EC_R_MISSING_PARAMETERS = 124;
enum EC_R_MISSING_PRIVATE_KEY = 125;
enum EC_R_NOT_A_NIST_PRIME = 135;
enum EC_R_NOT_A_SUPPORTED_NIST_PRIME = 136;
enum EC_R_NOT_IMPLEMENTED = 126;
enum EC_R_NOT_INITIALIZED = 111;
enum EC_R_NO_FIELD_MOD = 133;
enum EC_R_NO_PARAMETERS_SET = 139;
enum EC_R_PASSED_NULL_PARAMETER = 134;
enum EC_R_PKPARAMETERS2GROUP_FAILURE = 127;
enum EC_R_POINT_AT_INFINITY = 106;
enum EC_R_POINT_IS_NOT_ON_CURVE = 107;
enum EC_R_SLOT_FULL = 108;
enum EC_R_UNDEFINED_GENERATOR = 113;
enum EC_R_UNDEFINED_ORDER = 128;
enum EC_R_UNKNOWN_GROUP = 129;
enum EC_R_UNKNOWN_ORDER = 114;
enum EC_R_UNSUPPORTED_FIELD = 131;
enum EC_R_WRONG_CURVE_PARAMETERS = 145;
enum EC_R_WRONG_ORDER = 130;
